package com.coos.util;

import java.io.*;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 脚本处理类
 * 1.实现压缩单个js文件--去除注释换行和多个空格。
 * 最终输出一行字符串的脚本写法必须符合规范:
 * (1)变量定义后必须用;号结束。
 * (2)以赋值符=号定义的函数必须用;号结束,如：coos.test = function(){alert("test");};
 * (3)for if else 即使只有一句也要用{}包含起来,尤其是else必须用{}包含起来
 * 
 * 2.实现批量js压缩功能，压缩目录下的所有js文件到对应的输出目录下
 * 3.实现js合并功能 根据需要压缩的列表和输出文件路径及是否压缩生成对应文件
 * 4.使用前请先备份源文件,最好不要直接覆盖源文件，因使用本程序造成的任何损失自己负责
 * @author zheng
 * @version 1.0
 */
public class ScriptHelp
{
	//原文件编码，默认为UTF-8，通过setFileEncode("GBK");来改变
	private static String fileEncode = "UTF-8";
	//输出文件编码，默认为UTF-8，通过setToEncode("GBK");来改变
	private static String toEncode = "UTF-8";
	//是否压缩成一行，默认否.
	private static boolean oneline = false;
	//是否生成语法加亮html以便查看,默认否，通过setHightLight(true)来改变
	private static boolean hightLight = false;
	
	private static List<String>  fileList = new ArrayList<String>();
	private static String baseScriptPath = "E:/workspace/coos/coos/WebRoot/scripts";
	private static String miniScriptPath = baseScriptPath + "/mini";
	private static String sourceScriptPath = baseScriptPath + "/source";
	private static String labsPath = baseScriptPath + "/labs/";

	public static void main(String[] args)
	{
		//设置文件编码,默认为UTF-8
		//fileEncode = "GBK";
		//toEncode = "GBK";
		
		//设置压缩成一行,默认为false
		//oneline = true;
		
		//设置输出对应高亮代码的html,默认为false
		//hightLight = true;
		
		//合并实验室中的脚本文件为一个使用文件
		//mergeLabsJS();
		
		//批量压缩js文件,根据oneline属性决定是否压缩成一行
		//batchCompressJS(baseScriptPath,miniScriptPath);
		
		//批量压缩js文件,并压缩成一行
		//batchCompressMiniJS(baseScriptPath,miniScriptPath);
		
		//批量压缩js文件,只保持纯代码，不压缩成一行
		//batchCompressCleanJS(baseScriptPath,sourceScriptPath);
		
		//编译文件，发布版本.
		//先合并实验室的文件为使用脚本文件，然后批量压缩成纯代码文件，最后批量压缩成一行的mini文件
		buildVersion();
		
		//压缩单个js文件
		//compressSingleJS("D:/workspace/coos/WebRoot/scripts/coos.test.js","D:/workspace/coos/WebRoot/scripts/source/coos.test.js");
		//compressSingleJS("D:/workspace/coos/WebRoot/scripts/coos.js","D:/workspace/coos/WebRoot/scripts/mini/coos.js");
		//compressSingleJS("D:/workspace/coos/WebRoot/scripts/coos.ui.hightLight.js","D:/workspace/coos/WebRoot/scripts/mini/coos.ui.hightLight.js");

		/*
		//合并js文件
		List<String>  fileList = new ArrayList<String>();
		fileList.add("D:/workspace/coos/WebRoot/scripts/coos.js");
		fileList.add("D:/workspace/coos/WebRoot/scripts/coos.extend.ajax.js");
		String toFile = "D:/workspace/coos/WebRoot/scripts/mini/coos.js";
		mergeJS(fileList,toFile,true);
		*/
	}
	
	/**
	 * 编译文件，发布版本.
	 * 先合并实验室的文件为使用脚本文件，然后批量压缩成纯代码文件，最后批量压缩成一行的mini文件
	 */
	public static void buildVersion()
	{
		System.out.println("====编译文件，发布版本.====\r\n");
		mergeLabsJS();
		batchCompressSourceJS(baseScriptPath,sourceScriptPath);
		batchCompressMiniJS(baseScriptPath,miniScriptPath);
		
	}
	/**
	 * 批量压缩js文件,并压缩成一行
	 * @param baseScriptPath
	 * @param miniScriptPath
	 */
	public static void batchCompressMiniJS(String baseScriptPath,String miniScriptPath)
	{
		System.out.println("====批量压缩js文件,并压缩成一行.====\r\n");
		oneline = true;
		batchCompressJS(baseScriptPath,miniScriptPath);
	}
	
	/**
	 * 批量压缩js文件,只保持纯代码，不压缩成一行
	 * @param baseScriptPath
	 * @param sourceScriptPath
	 */
	public static void batchCompressSourceJS(String baseScriptPath,String sourceScriptPath)
	{
		System.out.println("====批量压缩js文件,只保持纯代码，不压缩成一行.====\r\n");
		oneline = false;
		batchCompressJS(baseScriptPath,sourceScriptPath);
	}
	
	/**
	 * 批量压缩js，压缩当前目录下的所有js
	 * @param baseScriptPath 要压缩的文件目录
	 * @param miniScriptPath 输出压缩后对应的目录
	 */
	@SuppressWarnings("unchecked")
	public static void batchCompressJS(String baseScriptPath,String miniScriptPath)
	{
		//获取当前目录下所以js文件路径(不包括子目录)
		List  fileList = getListFiles(baseScriptPath,"js",false);

		for (Iterator i = fileList.iterator(); i.hasNext();)
		{
			String fromFile = (String) i.next();
			String toFile = miniScriptPath +fromFile.substring(fromFile.lastIndexOf("/"), fromFile.length());
			compressSingleJS(fromFile,toFile);
		}
	}
	
	/**
	 * 压缩单个js文件
	 * @param fromFile
	 * @param toFile
	 */
	public static void compressSingleJS(String fromFile,String toFile)
	{
		String content = readFile(fromFile);
		content = compressJS(content);
		writeFile(content,toFile);
		if(hightLight)
		{
			writeFile(hightLightHTML(content),toFile.replaceAll("\\.js", ".html"));
		}
	}
	
	/**
	 * 合并实验室中的脚本文件为一个使用文件
	 */
	public static void mergeLabsJS()
	{
		System.out.println("====合并实验室中的脚本文件为一个使用文件.====\r\n");
		//merge extend base Labs JS
		List<String> base = new ArrayList<String>();
		String basePath = labsPath + "base/";
		base.add(basePath + "coos.js");
		base.add(basePath + "coos.ext.$.js");
		base.add(basePath + "coos.init.js");
		base.add(basePath + "coos.include.js");
		String baseFile = baseScriptPath + "/coos.js";
		mergeJS(base,baseFile,false);
		
		//merge extend base Labs JS
		List<String> extbase = new ArrayList<String>();
		String extPath = labsPath + "extbase/";
		extbase.add(extPath + "coos.ext.string.js");
		extbase.add(extPath + "coos.ext.array.js");
		extbase.add(extPath + "coos.ext.number.js");
		extbase.add(extPath + "coos.ext.hashmap.js");
		extbase.add(extPath + "coos.ext.event.js");
		extbase.add(extPath + "coos.ext.regex.js");
		String extbaseFile = baseScriptPath + "/coos.ext.base.js";
		mergeJS(extbase,extbaseFile,false);
		
		//merge ui base Labs JS
		List<String> uibase = new ArrayList<String>();
		String uiPath = labsPath + "uibase/";
		uibase.add(uiPath + "coos.ui.form.js");
		uibase.add(uiPath + "coos.ui.window.js");
		String uibaseFile = baseScriptPath + "/coos.ui.base.js";
		mergeJS(uibase,uibaseFile,false);
	}
	
	/**
	 * 合并js文件
	 * @param fileList 文件全路径的list,需要按顺序
	 * @param toFile 输出文件的全路径
	 * @param isCompress 是否压缩
	 * 
	 */
	@SuppressWarnings("unchecked")
	public static void mergeJS(List fileList,String toFile,Boolean isCompress)
	{
		String content = "";
		for (Iterator i = fileList.iterator(); i.hasNext();)
		{
			String fromFile = (String) i.next();
			content += readFile(fromFile);
		}
		if(isCompress == true)
		{
			content = compressJS(content);
			writeFile(content,toFile);
		}
		else
		{
			writeFile(content,toFile);
		}
		//输出高亮html
		if(hightLight)
		{
			writeFile(hightLightHTML(content),toFile.replaceAll("\\.js", ".html"));
		}
	}
	
	/**
	 * 去除注释、多个空格和换行，最终形成一行的字符串
	 * @param content 要压缩的内容
	 * @return 压缩后的内容
	 */
	public static String compressJS(String content)
	{
		//快速去除多行注释/**后面不能跟字符
		content = deleteMultirow(content);
		
		//去除注释和空行
		content = removeComments(content);
		//System.out.println(content);
		
		if(oneline)
		{
			//去除空格，和换行
			content = removeSpace(content);
		}

		//System.out.println(content);
		
		return content;
	}
	
	/**
	 * 内部使用的：去除多行注释，格式化换行为\r\n
	 * 多行注释必须以/* /** /****加回车开头*号后面不能带字符
	 * @param content
	 * @return
	 */
	private static String deleteMultirow(String content)
	{
		content = content.replaceAll("\\/\\*{1,}[\n]([\\S\\s]*?)\\*\\/", "");
		content = content.replaceAll("[\n]{2,}", "\n");
		return content;
	}

	/**
	 * 输出文件，编码为UTF-8 用记事本另存为：fileContent 全部为英文则为ansi 包含中文则为UTF-8
	 * @param content 要输出的文件内容
	 * @param comspec 全路径名
	 */
	public static void writeFile(String content,String toFile)
	{
		try
		{
			FileOutputStream fos = new FileOutputStream(toFile);
			
			Writer out = new OutputStreamWriter(fos,toEncode);
			out.write(content);
			float size = (float)content.getBytes(toEncode).length/1024;
			DecimalFormat df = new DecimalFormat("0.00");
			String filesize = df.format(size);
			System.out.println("输出文件：" + toFile + " 大小：" + filesize + "K " + content.getBytes(toEncode).length + "B" +"\r\n");
			out.close();
			fos.close();
		} catch (IOException e)
		{
			System.out.println("写文件操作出错！");
			e.printStackTrace();
		}
		
	}
	
	public static String hightLightHTML(String str)
	{
		String head = "<html>"
		 + "<head>"
		 + "<meta http-equiv=\"Content-Type\" content=\"text/html; charset="
		 + toEncode +"\"/>"
		 + "<title>hightLight</title>"
		 + "</head>"
		 + "<body>"
		 + "<pre id=\"showCode\">";
		String footer = "</pre>"
		 + "<script type=\"text/javascript\" src=\"coos.ui.hightLight.js\"></script>"
		 + "</body>"
		 + "</html>";
		
		return head + str + footer;
	}
	/**
	 * 读取文件内容
	 * @param filePath
	 * @return String
	 */
	public static String readFile(String filePath)
	{
		StringBuilder sb = new StringBuilder();
		try
		{
			File file = new File(filePath);
			FileInputStream fis = new FileInputStream(file);
			float size = (float)fis.available()/1024;
			DecimalFormat df = new DecimalFormat("0.00");
			String filesize = df.format(size);
			System.out.println("原始文件：" + filePath + " 大小：" + filesize + "K " + fis.available() + "B");
			BufferedReader reader = null;
			/*
			if(!"utf-8".equals(fileEncode.toLowerCase()))
			{
				InputStreamReader read = new InputStreamReader (fis,fileEncode);
				reader=new BufferedReader(read);
			}
			else
			{
				//读带有BOM的UTF-8文件乱码原因及解决方法,去除BOM后，写入文件时会出现乱码情况。
				//这种方法只适合读取文件内容到控制台或作为字符串输出，不适合重新输出到文件中。
				reader = new BufferedReader(new UnicodeReader(fis, Charset.defaultCharset().name()));
			}
			*/
			
			InputStreamReader read = new InputStreamReader (fis,fileEncode);
			reader=new BufferedReader(read);
			String s = reader.readLine();
			
			while (s != null)
			{
				sb.append(s);
				sb.append("\n");
				s = reader.readLine();
			}
			reader.close();
		} catch (IOException e)
		{
			e.printStackTrace();
		}
		return sb.toString();
	}
	
	/**
	 * @param path 文件路径
	 * @param suffix 后缀名
	 * @param isdepth 是否遍历子目录
	 * @return fileList
	 */
	@SuppressWarnings("unchecked")
	public static List getListFiles(String path, String suffix, boolean isdepth)
	{
		File file = new File(path);
		return listFile(path,file ,suffix, isdepth);
	}
	/**
	 * 获取当前目录下文件路径
	 * @param path
	 * @param f
	 * @param suffix
	 * @param isdepth
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static List listFile(String path, File f, String suffix, boolean isdepth) 
	{
		//是目录，同时需要遍历子目录
		String temp = path.replaceAll("/","\\\\");
		if ((f.isDirectory() && isdepth == true) || temp.equals(f.getAbsolutePath()))
		{
			File[] t = f.listFiles();
			for (int i = 0; i < t.length; i++)
			{
				listFile(path,t[i], suffix, isdepth);
			}
		}
		else 
		{
			addFilePath(f ,suffix, isdepth);
		}
		return fileList;
	}
	
	/**
	 * 添加文件路径到list中
	 * @param f
	 * @param suffix
	 * @param isdepth
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public static List addFilePath(File f, String suffix, boolean isdepth) 
	{
			String filePath =  f.getAbsolutePath().replaceAll("\\\\", "/");
			if(suffix !=null)
			{
				int begIndex = filePath.lastIndexOf(".");
				String tempsuffix = "";
				
				if(begIndex != -1)//防止是文件但却没有后缀名结束的文件
				{
					tempsuffix = filePath.substring(begIndex + 1, filePath.length());
				}
				if(tempsuffix.equals(suffix))
				{
					fileList.add(filePath);
				}
			}
			else
			{
				fileList.add(filePath);//后缀名为null则为所有文件
			}
		return fileList;
	}

	
	// COMMENCODES为普通代码模式,
	//PRECOMMENTS为斜杠模式,
	//MORELINECOMMENTS为多行注释模式,
	// STARMODEL为多行注释下星号模式，
	//SINGLELINECOMMENTS为单行注释模式，
	//STRINGMODEL为字符串模式，
	//由于javascript里面可以有单引号和双引号同时使用，所以必须分开对待
	//STRINSINGLE为单引号字符串模式，
	//STRINGDOUBLE为双引号字符串模式，
	
	// TRANSFERMODEL为字符串转义模式
	private static enum model {
		COMMENCODES, PRECOMMENTS, MORELINECOMMENTS, STARMODEL, SINGLELINECOMMENTS, STRINGMODEL, STRINSINGLE, STRINGDOUBLE, TRANSFERMODEL
	}
	//stats记录状态
	private static model stats = model.COMMENCODES;
	
	public static String removeComments(String content)
	{
		if ("".equals(content))
		{
            return "";
        }
		StringBuilder s = new StringBuilder();
        int sz = content.length();
        for (int i = 0; i < sz; i++)
        {
        	switch (content.charAt(i))
        	{
			case '/':
				if (stats == model.COMMENCODES) {// 如果当前位普通代码模式则转到斜杠模式
					stats = model.PRECOMMENTS;
				} else if (stats == model.PRECOMMENTS) {// 如果当前为斜杠模式则转到单行注释模式
					stats = model.SINGLELINECOMMENTS;
					//s.append("  ");
				} else if (stats == model.MORELINECOMMENTS) {//
					//s.append(" ");
				} else if (stats == model.STARMODEL) {// 如果当前为星号模式则转到普通代码模式
					stats = model.COMMENCODES;
					s.append(" ");
				} else if (stats == model.SINGLELINECOMMENTS) {
					//s.append(" ");
				} else if (stats == model.STRINGMODEL) {
					s.append("/");
				} else if (stats == model.TRANSFERMODEL) {
					stats = model.STRINGMODEL;
					s.append("/");
				}
				break;
			case '*':
				if (stats == model.COMMENCODES) {
					s.append("*");
				} else if (stats == model.PRECOMMENTS) {// 如果为斜杠模式则转到多行注释模式
					stats = model.MORELINECOMMENTS;
					//s.append("  ");
				} else if (stats == model.MORELINECOMMENTS) {// 如果当前为多行注释模式则转到星号模式
					stats = model.STARMODEL;
					//s.append(" ");
				} else if (stats == model.STARMODEL) {
					//s.append(" ");
				} else if (stats == model.SINGLELINECOMMENTS) {
					//s.append(" ");
				} else if (stats == model.STRINGMODEL) {
					s.append("*");
				} else if (stats == model.TRANSFERMODEL) {
					s.append("*");
				}
				break;
			case '"':
				if (stats == model.COMMENCODES) {// 如果当前为普通代码模式则转到字符串模式
					stats = model.STRINGMODEL;
					s.append("\"");
				} else if (stats == model.PRECOMMENTS) {// 如果当前为斜杠模式则转到普通代码模式
					stats = model.COMMENCODES;
					s.append("/\"");
				} else if (stats == model.STARMODEL) {// 如果当前为星号模式则转到多行注释模式
					stats = model.MORELINECOMMENTS;
					//s.append(" ");
				} else if (stats == model.SINGLELINECOMMENTS) {
					//s.append(" ");
				} else if (stats == model.STRINGMODEL) {// 如果当前为字符串模式则转到普通代码模式
					stats = model.COMMENCODES;
					s.append("\"");
				} else if (stats == model.TRANSFERMODEL) {// 如果当前为转义模式则转到字符串格式
					stats = model.STRINGMODEL;
					s.append("\"");
				}
				break;
			case '\'':
				if (stats == model.COMMENCODES) {
					stats = model.STRINGMODEL;
					s.append("'");
				} else if (stats == model.PRECOMMENTS) {
					stats = model.COMMENCODES;
					s.append("/'");
				} else if (stats == model.STARMODEL) {
					stats = model.MORELINECOMMENTS;
					//s.append(" ");
				} else if (stats == model.SINGLELINECOMMENTS) {
					//s.append(" ");
				} else if (stats == model.STRINGMODEL) {
					stats = model.COMMENCODES;
					s.append("'");
				} else if (stats == model.TRANSFERMODEL) {
					stats = model.STRINGMODEL;
					s.append("'");
				}
				break;
			case '\\':
				if (stats == model.COMMENCODES) {
					s.append("\\");
				} else if (stats == model.PRECOMMENTS) {// 如果当前为斜杠模式则转到普通代码格式
					stats = model.COMMENCODES;
					s.append("/\\");
				} else if (stats == model.MORELINECOMMENTS) {
					//s.append(" ");
				} else if (stats == model.STARMODEL) {// 如果当前为星号模式则转到多行注释模式
					stats = model.MORELINECOMMENTS;
					//s.append(" ");
				} else if (stats == model.SINGLELINECOMMENTS) {
					//s.append(" ");
				} else if (stats == model.STRINGMODEL) {// 如果当前为字符串模式则转到字符串转移模式
					stats = model.TRANSFERMODEL;
					s.append("\\");
				} else if (stats == model.TRANSFERMODEL) {// 如果当前为字符串转义模式则转到字符串模式
					stats = model.STRINGMODEL;
					s.append("\\");
				}
				break;
			case '\n':
				if (stats == model.COMMENCODES) {
					s.append("\n");
				} else if (stats == model.PRECOMMENTS) {// 如果当前为斜杠模式则转到普通代码格式
					stats = model.COMMENCODES;
					s.append("/\n");
				} else if (stats == model.MORELINECOMMENTS) {
					s.append("\n");
				} else if (stats == model.STARMODEL) {// 如果当前为星号模式则转到多行注释模式
					stats = model.MORELINECOMMENTS;
					s.append("\n");
				} else if (stats == model.SINGLELINECOMMENTS) {// 如果当前为单行注释模式则转到普通代码格式
					stats = model.COMMENCODES;
					s.append("\n");
				} else if (stats == model.STRINGMODEL) {
					s.append("\n");
				} else if (stats == model.TRANSFERMODEL) {
					s.append("\\n");
				}
				break;
			default:
				if (stats == model.COMMENCODES) {
					s.append(content.charAt(i));
				} else if (stats == model.PRECOMMENTS) {// 如果当前为斜杠模式则转到普通代码格式
					stats = model.COMMENCODES;
					s.append("/" + content.charAt(i));
				} else if (stats == model.STARMODEL) {// 如果当前为星号模式则转到多行注释模式
					stats = model.MORELINECOMMENTS;
					//s.append(" ");
				} else if (stats == model.SINGLELINECOMMENTS) {
					//s.append(" ");
				} else if (stats == model.STRINGMODEL) {
					s.append(content.charAt(i));
				} else if (stats == model.TRANSFERMODEL) {// 如果当前为字符串转义模式则转到字符串模式
					stats = model.STRINGMODEL;
					s.append(content.charAt(i));
				}
				break;
			}
        }
        String str = s.toString();
        str = str.replaceAll("\\s{1,}[\n]", "\n");
        str = str.replaceAll("[\n]{2,}", "\n");
        stats = model.COMMENCODES;
    	return str;
	}
	
	
	// COMMENCODES为普通代码模式,
	//SPACE为空格模式,
	//STRINGMODEL为字符串模式，
	//TRANSFERMODEL为字符串转义模式
	//DELETE为删除模式，遇到= { }删除空格
	private static enum model2 {
		COMMENCODES, SPACE, STRINGMODEL, TRANSFERMODEL, DELETE
	}
	//stats记录状态
	private static model2 stats2 = model2.COMMENCODES;
	
	public static String removeSpace(String content)
	{
		if ("".equals(content))
		{
            return "";
        }
		StringBuilder s = new StringBuilder();
        int sz = content.length();
        for (int i = 0; i < sz; i++)
        {
        	switch (content.charAt(i))
        	{
        	case ' ':
				if (stats2 == model2.COMMENCODES) {// 如果当前位普通代码模式则转到空格模式
					stats2 = model2.SPACE;
					s.append(" ");
				}
				else if (stats2 == model2.STRINGMODEL) {//如果为字符串模式则直接添加
					s.append(" ");
				}else if (stats2 == model2.TRANSFERMODEL) {//如果为字符串转义模式则直接添加
					s.append(" ");
				}
				break;
			case '"':
				if (stats2 == model2.COMMENCODES) {// 如果当前为普通代码模式则转到字符串模式
					stats2 = model2.STRINGMODEL;
					s.append("\"");
				}else if (stats2 == model2.TRANSFERMODEL) {//如果为字符串转义模式则转到字符串模式
					stats2 = model2.STRINGMODEL;
					s.append("\"");
				}
				else
				{
					stats2 = model2.STRINGMODEL;
					s.append("\"");
				}
				break;
			case '\'':
				if (stats2 == model2.COMMENCODES) {
					stats2 = model2.STRINGMODEL;
					s.append("'");
				}else if (stats2 == model2.TRANSFERMODEL) {//如果为字符串转义模式则转到字符串模式
					stats2 = model2.STRINGMODEL;
					s.append("'");
				}
				else
				{
					stats2 = model2.STRINGMODEL;
					s.append("'");
				}
				break;
			case '\\':
				if (stats2 == model2.COMMENCODES) {
					s.append("\\");
				} else if (stats2 == model2.STRINGMODEL) {// 如果当前为字符串模式则转到字符串转移模式
					stats2 = model2.TRANSFERMODEL;
					s.append("\\");
				} else 
				{
					s.append("\\");
				}
				break;
			case '\n':
				stats2 = model2.COMMENCODES;//\n直接替换，转到普通模式
				break;
			case '\t'://tab键
				if (stats2 == model2.STRINGMODEL) {// 如果当前为字符串模式则转到字符串转移模式
					s.append("\t");
				}
				stats2 = model2.COMMENCODES;//\n直接替换，转到普通模式
				break;
			case '=':
				if (stats2 == model2.STRINGMODEL) {
					s.append("=");
				}
				else if (stats2 == model2.COMMENCODES) {
					stats2 = model2.DELETE;
					s.append("=");
				}else if (stats2 == model2.SPACE) {
					stats2 = model2.DELETE;
					s.deleteCharAt(s.length()-1);
					s.append("=");
				}
				else
				{
					stats2 = model2.DELETE;
					s.append("=");
				}
				break;
			case '{':
				if (stats2 == model2.STRINGMODEL) {
					s.append("{");
				}
				else if (stats2 == model2.COMMENCODES) {
					stats2 = model2.DELETE;
					s.append("{");
				}else if (stats2 == model2.SPACE) {
					stats2 = model2.DELETE;
					s.deleteCharAt(s.length()-1);
					s.append("{");
				}
				else
				{
					stats2 = model2.DELETE;
					s.append("{");
				}
				break;
			case '}':
				if (stats2 == model2.STRINGMODEL) {
					s.append("}");
				}
				else if (stats2 == model2.COMMENCODES) {
					stats2 = model2.DELETE;
					s.append("}");
				}else if (stats2 == model2.SPACE) {
					stats2 = model2.DELETE;
					s.deleteCharAt(s.length()-1);
					s.append("}");
				}
				else
				{
					stats2 = model2.DELETE;
					s.append("}");
				}
				break;
			default:
				if (stats2 == model2.COMMENCODES) {
					s.append(content.charAt(i));
				} else if (stats2 == model2.STRINGMODEL) {
					s.append(content.charAt(i));
				} else if (stats2 == model2.TRANSFERMODEL) {// 如果当前为字符串转义模式则转到字符串模式
					stats2 = model2.STRINGMODEL;
					s.append(content.charAt(i));
				}
				else
				{
					stats2 = model2.COMMENCODES;
					s.append(content.charAt(i));
				}
				break;
			}
        }
        //重新设置状态，避免下次保持到最后的状态
        stats2 = model2.COMMENCODES;
    	return s.toString();
	}
	
}
